package cn.harry.cabinet

import android.annotation.SuppressLint
import android.app.Application
import android.util.Log
import cn.harry.cabinet.model.entity.Configuration
import cn.harry.cabinet.repository.ConfigurationRepository
import cn.harry.cabinet.server.KtorServer
import cn.harry.cabinet.theme.manager.ThemeManager
import cn.harry.cabinet.utils.AppConfigKeys
import cn.harry.cabinet.utils.IpUtil
import cn.harry.cabinet.utils.VoiceHelper
import com.arcsoft.face.ErrorInfo
import com.arcsoft.face.FaceEngine
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.SupervisorJob
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext
import java.util.Date

/**
 * SmartCabinet应用程序类
 * 负责管理全局的KtorServer实例
 */
class SmartCabinetApplication : Application() {
    
    companion object {
        private const val TAG = "SmartCabinetApp"
        @SuppressLint("StaticFieldLeak")
        lateinit var ktorServer: KtorServer
            private set
    }
    
    // 应用级别的协程作用域
    private val applicationScope = CoroutineScope(SupervisorJob() + Dispatchers.Main)
    
    // Repository实例
    private lateinit var configRepository: ConfigurationRepository
    
    override fun onCreate() {
        super.onCreate()
        
        // 初始化Repository
        configRepository = ConfigurationRepository(this)
        
        // 数据库会在首次访问时自动初始化（通过 init_data.sql）
        // 这里可选地检查版本升级
        checkDatabaseVersion()
        
        // 初始化主题系统
        initializeTheme()
        
        // 初始化TTS语音播报
        initializeTTS()
        
        // 检查并保存人脸识别引擎激活状态
        checkAndSaveFaceEngineActivation()
        
        // 初始化KtorServer
        ktorServer = KtorServer(this)
        
        // 自动启动服务器
        autoStartServer()
        
        Log.i(TAG, "SmartCabinet应用程序已初始化")
    }
    
    /**
     * 检查数据库版本（可选）
     * 用于版本升级时的增量初始化
     */
    private fun checkDatabaseVersion() {
        applicationScope.launch {
            try {
                // 可选：检查并执行版本升级
                // AppInitializer.checkAndUpgrade(this@SmartCabinetApplication)
                Log.d(TAG, "数据库版本检查完成")
            } catch (e: Exception) {
                Log.e(TAG, "数据库版本检查失败", e)
            }
        }
    }
    
    /**
     * 自动启动Ktor服务器
     * 从数据库读取配置的端口和主机，如果不存在则使用默认值
     */
    private fun autoStartServer() {
        applicationScope.launch {
            try {
                // 从数据库读取服务器配置
                val (port, host) = withContext(Dispatchers.IO) {
                    loadServerConfigFromDatabase()
                }
                
                // 使用配置的端口和主机启动服务器
                ktorServer.start(port, host)
                Log.i(TAG, "Ktor服务器已自动启动 - http://$host:$port")
            } catch (e: Exception) {
                Log.e(TAG, "自动启动Ktor服务器失败: ${e.message}")
            }
        }
    }
    
    /**
     * 从数据库加载服务器配置
     * @return Pair(port, host)
     */
    private suspend fun loadServerConfigFromDatabase(): Pair<Int, String> {
        return try {
            // 加载端口配置
            val portConfig = configRepository.getByTypeAndKey(
                AppConfigKeys.TYPE_NETWORK,
                AppConfigKeys.KEY_NETWORK_SERVER_PORT
            )
            
            // 判断端口值是否为空或无效，默认 8888
            val portValue = portConfig?.value
            val port = if (portValue.isNullOrBlank()) {
                Log.i(TAG, "端口配置为空，使用默认值: 8888")
                8888
            } else {
                portValue.toIntOrNull() ?: run {
                    Log.w(TAG, "端口配置无效: $portValue，使用默认值: 8888")
                    8888
                }
            }
            
            // 加载主机配置
            val hostConfig = configRepository.getByTypeAndKey(
                AppConfigKeys.TYPE_NETWORK,
                AppConfigKeys.KEY_NETWORK_SERVER_HOST
            )
            
            // 判断主机值是否为空，默认使用本地IP或 0.0.0.0
            val hostValue = hostConfig?.value
            val host = if (hostValue.isNullOrBlank()) {
                val defaultHost = IpUtil.getLocalIpAddress() ?: "0.0.0.0"
                Log.i(TAG, "主机配置为空，使用默认值: $defaultHost")
                defaultHost
            } else {
                hostValue
            }
            
            Log.i(TAG, "服务器配置加载成功 - Host: $host, Port: $port")
            Pair(port, host)
        } catch (e: Exception) {
            Log.e(TAG, "从数据库加载服务器配置失败，使用默认值: ${e.message}")
            val defaultHost = IpUtil.getLocalIpAddress() ?: "0.0.0.0"
            Pair(8888, defaultHost)
        }
    }
    
    /**
     * 初始化主题系统
     */
    private fun initializeTheme() {
        applicationScope.launch {
            try {
                // 从数据库加载保存的主题设置
                val savedTheme = ThemeManager.loadThemeFromDatabase(this@SmartCabinetApplication)
                Log.i(TAG, "已加载主题: ${savedTheme.displayName}")
            } catch (e: Exception) {
                Log.w(TAG, "主题初始化失败，使用默认主题: ${e.message}")
                // 使用默认主题
                ThemeManager.setTheme(this@SmartCabinetApplication, ThemeManager.Theme.TECH_BLUE)
            }
        }
    }
    
    /**
     * 初始化TTS语音播报
     */
    private fun initializeTTS() {
        VoiceHelper.initialize(this) { success ->
            if (success) {
                Log.i(TAG, "TTS语音播报初始化成功")
            } else {
                Log.w(TAG, "TTS语音播报初始化失败")
            }
        }
    }
    
    /**
     * 检查并保存人脸识别引擎激活状态
     */
    private fun checkAndSaveFaceEngineActivation() {
        applicationScope.launch {
            try {
                Log.i(TAG, "=== 开始检查人脸识别引擎激活状态 ===")
                
                val isActivated = withContext(Dispatchers.IO) {
                    checkFaceEngineActivation()
                }
                
                // 保存激活状态到数据库
                saveFaceEngineActivationStatus(isActivated)
                
                if (isActivated) {
                    Log.i(TAG, "✅ 人脸识别引擎已激活")
                } else {
                    Log.w(TAG, "⚠️ 人脸识别引擎未激活")
                }
                
            } catch (e: Exception) {
                Log.e(TAG, "检查人脸识别引擎激活状态失败", e)
                // 保存失败状态
                saveFaceEngineActivationStatus(false)
            }
        }
    }
    
    /**
     * 检查人脸识别引擎是否激活
     */
    private suspend fun checkFaceEngineActivation(): Boolean {
        return try {
            // 从配置表中读取 APP_ID 和 SDK_KEY
            val appId = configRepository.getByTypeAndKey(
                AppConfigKeys.TYPE_FACE_RECOGNITION,
                AppConfigKeys.KEY_FACE_APP_ID
            )?.value
            
            val sdkKey = configRepository.getByTypeAndKey(
                AppConfigKeys.TYPE_FACE_RECOGNITION,
                AppConfigKeys.KEY_FACE_SDK_KEY
            )?.value
            
            if (appId.isNullOrEmpty() || sdkKey.isNullOrEmpty()) {
                Log.w(TAG, "人脸识别 APP_ID 或 SDK_KEY 未配置")
                return false
            }
            
            Log.d(TAG, "从配置表读取: APP_ID=${appId.take(10)}..., SDK_KEY=${sdkKey.take(10)}...")
            
            // 尝试在线激活（如果已激活会返回 MERR_ASF_ALREADY_ACTIVATED）
            val activeCode = FaceEngine.activeOnline(this, appId, sdkKey)
            
            // 如果返回 MOK 或 MERR_ASF_ALREADY_ACTIVATED，说明已激活
            val isActivated = activeCode == ErrorInfo.MOK || 
                             activeCode == ErrorInfo.MERR_ASF_ALREADY_ACTIVATED
            
            Log.d(TAG, "人脸引擎激活检查结果: $activeCode, 已激活: $isActivated")
            isActivated
            
        } catch (e: Exception) {
            Log.e(TAG, "检查人脸引擎激活状态异常", e)
            false
        }
    }
    
    /**
     * 保存人脸识别引擎激活状态到数据库
     */
    private suspend fun saveFaceEngineActivationStatus(isActivated: Boolean) {
        withContext(Dispatchers.IO) {
            try {
                // 检查是否已存在配置
                val existingConfig = configRepository.getByTypeAndKey(
                    AppConfigKeys.TYPE_FACE_RECOGNITION,
                    AppConfigKeys.KEY_FACE_ACTIVATED
                )
                
                if (existingConfig != null) {
                    // 更新现有配置
                    val updatedConfig = existingConfig.copy(
                        value = isActivated.toString(),
                        updateTime = Date()
                    )
                    configRepository.update(updatedConfig)
                    Log.d(TAG, "已更新人脸引擎激活状态: $isActivated")
                } else {
                    // 创建新配置
                    val newConfig = Configuration(
                        type = AppConfigKeys.TYPE_FACE_RECOGNITION,
                        key = AppConfigKeys.KEY_FACE_ACTIVATED,
                        value = isActivated.toString(),
                        createTime = Date(),
                        updateTime = Date()
                    )
                    configRepository.create(newConfig)
                    Log.d(TAG, "已保存人脸引擎激活状态: $isActivated")
                }
                
            } catch (e: Exception) {
                Log.e(TAG, "保存人脸引擎激活状态失败", e)
            }
        }
    }
    
    override fun onTerminate() {
        super.onTerminate()
        // 应用终止时停止服务器
        ktorServer.stop()
        // 释放TTS资源
        VoiceHelper.shutdown()
        Log.i(TAG, "SmartCabinet应用程序已终止")
    }
} 